/// Test wrapper for RpcStateReader that overrides execution flags to skip validation.
struct TestRpcVirtualBlockExecutor(RpcVirtualBlockExecutor);

impl VirtualBlockExecutor for TestRpcVirtualBlockExecutor {
    fn block_context(
        &self,
        block_number: BlockNumber,
    ) -> Result<blockifier::context::BlockContext, VirtualBlockExecutorError> {
        self.0.block_context(block_number)
    }

    fn state_reader(
        &self,
        block_number: BlockNumber,
    ) -> Result<
        impl blockifier::state::state_reader_and_contract_manager::FetchCompiledClasses
        + Send
        + Sync
        + 'static,
        VirtualBlockExecutorError,
    > {
        self.0.state_reader(block_number)
    }

    // Override the default implementation to skip validation.
    fn convert_invoke_txs(
        txs: Vec<(Transaction, TransactionHash)>,
    ) -> Result<Vec<BlockifierTransaction>, VirtualBlockExecutorError> {
        // Call the default trait implementation.
        let mut blockifier_txs = RpcVirtualBlockExecutor::convert_invoke_txs(txs)?;

        // Modify validate flag to false for all transactions.
        for tx in &mut blockifier_txs {
            if let BlockifierTransaction::Account(account_tx) = tx {
                account_tx.execution_flags.validate = false;
            }
        }

        Ok(blockifier_txs)
    }
}

/// Constructs an Invoke transaction that calls `balanceOf` on the STRK token contract.
///
/// Since we skip validation and fee charging, we can use dummy values for signature,
/// nonce, and resource bounds.
fn construct_balance_of_invoke() -> (Transaction, TransactionHash) {
    let strk_token = ContractAddress::try_from(STRK_TOKEN_ADDRESS).unwrap();
    let sender = ContractAddress::try_from(SENDER_ADDRESS).unwrap();

    // Calldata for account's __execute__ (Cairo 0 OZ account format):
    // [call_array_len, call_array..., calldata_len, calldata...]